/**
 * @copyright Copyright (c) 2025 CSG Digital Grid Technology (Guangdong) Co., Ltd.
 * @author Chen Yongjie
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <CUnit/CUnit.h>
#include <limits.h>
#include "test_cpu.h"
#include "main.h"

// 声明被测试的静态函数
extern void get_cpu_info(dev_cpu_info_t *cpu_info);
extern int cal_cpu_used_rate(dev_cpu_info_t *first, dev_cpu_info_t *second);

/**
 * @brief 测试 get_cpu_info 函数在正常情况下的行为
 * 
 * 测试步骤：
 * 1. 创建 dev_cpu_info_t 结构体实例
 * 2. 调用 get_cpu_info 函数获取 CPU 信息
 * 3. 验证获取的数据是否有效
 * 
 * 预期结果：
 * 1. 函数成功执行
 * 2. 结构体中的各个字段都被正确填充
 * 3. CPU 名称应该是 "cpu"
 * 4. 各个计数器值应该大于 0
 */
void test_get_cpu_info_normal(void)
{
    dev_cpu_info_t cpu_info = {0};
    
    // 调用被测试函数
    get_cpu_info(&cpu_info);
    
    // 验证 CPU 名称
    CU_ASSERT_STRING_EQUAL(cpu_info.name, "cpu");
    
    // 验证各个计数器值是否有效（应该大于0）
    CU_ASSERT_TRUE(cpu_info.user > 0);
    CU_ASSERT_TRUE(cpu_info.system > 0);
    CU_ASSERT_TRUE(cpu_info.idle > 0);
}

/**
 * @brief 测试 get_cpu_info 函数在文件不存在的情况下的行为
 * 
 * 测试步骤：
 * 1. 临时重命名 /proc/stat 文件
 * 2. 调用 get_cpu_info 函数
 * 3. 验证函数的错误处理
 * 4. 恢复 /proc/stat 文件
 * 
 * 预期结果：
 * 1. 函数应该优雅地处理文件不存在的情况
 * 2. 结构体的值应该保持为 0
 */
void test_get_cpu_info_file_not_exist(void)
{
    dev_cpu_info_t cpu_info = {0};
    
    // 保存原始值
    unsigned int original_user = cpu_info.user;
    unsigned int original_system = cpu_info.system;
    unsigned int original_idle = cpu_info.idle;
    
    // 通过设置错误的文件权限来模拟文件不存在的情况
    system("sudo chmod 000 /proc/stat");
    
    // 调用被测试函数
    get_cpu_info(&cpu_info);
    
    // 恢复文件权限
    system("sudo chmod 444 /proc/stat");
    
    // 验证在文件访问失败时，结构体的值应该保持不变
    CU_ASSERT_EQUAL(cpu_info.user, original_user);
    CU_ASSERT_EQUAL(cpu_info.system, original_system);
    CU_ASSERT_EQUAL(cpu_info.idle, original_idle);
}

/**
 * @brief 测试 get_cpu_info 函数在文件内容格式错误的情况
 * 
 * 测试步骤：
 * 1. 创建一个格式错误的临时文件
 * 2. 替换原始的 /proc/stat 文件
 * 3. 调用 get_cpu_info 函数
 * 4. 恢复原始文件
 * 
 * 预期结果：
 * 1. 函数应该能够优雅地处理格式错误的情况
 * 2. 返回的结构体中所有值应该为0
 */
void test_get_cpu_info_invalid_format(void)
{
    dev_cpu_info_t cpu_info = {0};
    
    // 创建一个临时文件模拟错误格式的/proc/stat
    FILE *fp = fopen("test_stat", "w");
    fprintf(fp, "cpu invalid format data\n");
    fclose(fp);
    
    // 备份原始文件并替换
    system("mv /proc/stat /proc/stat.bak");
    system("cp test_stat /proc/stat");
    
    // 调用被测试函数
    get_cpu_info(&cpu_info);
    
    // 恢复原始文件
    system("mv /proc/stat.bak /proc/stat");
    system("rm test_stat");
    
    // 验证错误情况下的返回值
    CU_ASSERT_EQUAL(cpu_info.user, 0);
    CU_ASSERT_EQUAL(cpu_info.system, 0);
    CU_ASSERT_EQUAL(cpu_info.idle, 0);
}

/**
 * @brief 测试 get_cpu_info 函数对空指针参数的处理
 * 
 * 测试步骤：
 * 1. 使用 NULL 指针调用函数
 * 
 * 预期结果：
 * 1. 函数应该能够优雅地处理 NULL 指针
 * 2. 不应该发生段错误
 */
void test_get_cpu_info_null_pointer(void)
{
    // 使用 NULL 指针调用函数
    get_cpu_info(NULL);
    
    // 如果程序能够继续执行到这里，说明函数正确处理了 NULL 指针
    CU_PASS("Function handled NULL pointer gracefully");
}

// 声明被测试的静态函数
extern int cal_cpu_used_rate(dev_cpu_info_t *first, dev_cpu_info_t *second);

/**
 * @brief 测试 cal_cpu_used_rate 函数在正常情况下的行为
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例，模拟两个时间点的 CPU 信息
 * 2. 设置合理的 CPU 使用时间数据
 * 3. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 4. 验证计算结果是否符合预期
 * 
 * 预期结果：
 * 1. 函数应该正确计算出 CPU 使用率
 * 2. 结果应该在 0-100 之间
 */
void test_cal_cpu_used_rate_normal(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置第一个时间点的数据
    first.user = 1000;
    first.nice = 200;
    first.system = 500;
    first.idle = 8300;
    
    // 设置第二个时间点的数据（总时间增加10000，活动时间增加3000）
    second.user = 2500;    // 增加1500
    second.nice = 400;     // 增加200
    second.system = 1800;  // 增加1300
    second.idle = 15300;   // 增加7000
    
    // 计算 CPU 使用率
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果是否在合理范围内
    CU_ASSERT_TRUE(usage >= 0 && usage <= 100);
    // 验证具体计算结果（预期约为30%）
    CU_ASSERT_EQUAL(usage, 30);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在 CPU 时间相同的情况
 * 
 * 测试步骤：
 * 1. 创建两个相同的 dev_cpu_info_t 结构体实例
 * 2. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 
 * 预期结果：
 * 1. 当两个时间点的数据相同时，CPU 使用率应该为 0
 */
void test_cal_cpu_used_rate_same_time(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置相同的数据
    first.user = second.user = 1000;
    first.nice = second.nice = 200;
    first.system = second.system = 500;
    first.idle = second.idle = 8300;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果为0
    CU_ASSERT_EQUAL(usage, 0);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在空闲时间增加的情况
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例
 * 2. 仅增加空闲时间
 * 3. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 
 * 预期结果：
 * 1. 当只有空闲时间增加时，CPU 使用率应该为 0
 */
void test_cal_cpu_used_rate_idle_increase(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置初始数据
    first.user = 1000;
    first.nice = 200;
    first.system = 500;
    first.idle = 8300;
    
    // 只增加空闲时间
    second.user = first.user;
    second.nice = first.nice;
    second.system = first.system;
    second.idle = first.idle + 1000;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果为0
    CU_ASSERT_EQUAL(usage, 0);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在用户时间增加的情况
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例
 * 2. 仅增加用户时间
 * 3. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 
 * 预期结果：
 * 1. 当只有用户时间增加时，CPU 使用率应该为 100%
 */
void test_cal_cpu_used_rate_user_increase(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置初始数据
    first.user = 1000;
    first.nice = 200;
    first.system = 500;
    first.idle = 8300;
    
    // 只增加用户时间
    second.user = first.user + 1000;
    second.nice = first.nice;
    second.system = first.system;
    second.idle = first.idle;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果为100
    CU_ASSERT_EQUAL(usage, 100);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在系统时间增加的情况
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例
 * 2. 仅增加系统时间
 * 3. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 
 * 预期结果：
 * 1. 当只有系统时间增加时，CPU 使用率应该为 100%
 */
void test_cal_cpu_used_rate_system_increase(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置初始数据
    first.user = 1000;
    first.nice = 200;
    first.system = 500;
    first.idle = 8300;
    
    // 只增加系统时间
    second.user = first.user;
    second.nice = first.nice;
    second.system = first.system + 1000;
    second.idle = first.idle;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果为100
    CU_ASSERT_EQUAL(usage, 100);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在所有时间同比例增加的情况
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例
 * 2. 所有时间都增加相同的比例
 * 3. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 
 * 预期结果：
 * 1. 当所有时间同比例增加时，CPU 使用率应该保持不变
 */
void test_cal_cpu_used_rate_proportional_increase(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置初始数据
    first.user = 1000;
    first.nice = 200;
    first.system = 500;
    first.idle = 8300;
    
    // 所有值都增加一倍
    second.user = first.user * 2;
    second.nice = first.nice * 2;
    second.system = first.system * 2;
    second.idle = first.idle * 2;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 计算预期的 CPU 使用率
    int expected_usage = (int)100 * (first.user + first.nice + first.system) / 
                        (first.user + first.nice + first.system + first.idle);
    
    // 验证结果与预期相同
    CU_ASSERT_EQUAL(usage, expected_usage);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在时间溢出的情况
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例
 * 2. 设置接近最大值的时间数据
 * 3. 调用 cal_cpu_used_rate 计算 CPU 使用率
 * 
 * 预期结果：
 * 1. 函数应该正确处理大数值的情况
 * 2. 返回值应该在合理范围内（0-100）
 */
void test_cal_cpu_used_rate_overflow(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置接近最大值的数据
    first.user = UINT_MAX - 1000;
    first.nice = UINT_MAX - 2000;
    first.system = UINT_MAX - 3000;
    first.idle = UINT_MAX - 4000;
    
    // 设置稍大的值
    second.user = UINT_MAX;
    second.nice = UINT_MAX - 1500;
    second.system = UINT_MAX - 2500;
    second.idle = UINT_MAX - 3500;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果在合理范围内
    CU_ASSERT_TRUE(usage >= 0 && usage <= 100);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在参数为空指针的情况
 * 
 * 测试步骤：
 * 1. 使用 NULL 指针调用函数
 * 2. 使用一个有效指针和一个 NULL 指针调用函数
 * 
 * 预期结果：
 * 1. 函数应该能够优雅地处理 NULL 指针
 * 2. 返回值应该为0表示错误
 */
void test_cal_cpu_used_rate_null_pointer(void)
{
    dev_cpu_info_t valid_info = {0};
    
    // 测试两个参数都为 NULL
    int usage = cal_cpu_used_rate(NULL, NULL);
    CU_ASSERT_EQUAL(usage, 0);
    
    // 测试第一个参数为 NULL
    usage = cal_cpu_used_rate(NULL, &valid_info);
    CU_ASSERT_EQUAL(usage, 0);
    
    // 测试第二个参数为 NULL
    usage = cal_cpu_used_rate(&valid_info, NULL);
    CU_ASSERT_EQUAL(usage, 0);
}

/**
 * @brief 测试 get_cpuUsage 函数在正常情况下的行为
 * 
 * 测试步骤：
 * 1. 调用 get_cpuUsage 函数获取 CPU 使用率
 * 2. 验证返回值是否在合理范围内
 * 
 * 预期结果：
 * 1. 函数应该返回一个 0-100 之间的值
 * 2. 函数执行不应该出现错误
 */
void test_get_cpuUsage_normal(void)
{
    uint8_t usage = get_cpuUsage();
    
    // 验证 CPU 使用率是否在合理范围内（0-100%）
    CU_ASSERT_TRUE(usage >= 0 && usage <= 100);
}

/**
 * @brief 测试 get_cpuUsage 函数在连续调用时的行为
 * 
 * 测试步骤：
 * 1. 连续调用两次 get_cpuUsage 函数
 * 2. 验证两次返回值是否都在合理范围内
 * 3. 验证两次返回值的差异是否在合理范围内
 * 
 * 预期结果：
 * 1. 两次返回值都应该在 0-100 之间
 * 2. 两次返回值的差异不应该过大（考虑到实际系统负载可能波动）
 */
void test_get_cpuUsage_continuous(void)
{
    uint8_t usage1 = get_cpuUsage();
    uint8_t usage2 = get_cpuUsage();
    
    // 验证两次返回值都在合理范围内
    CU_ASSERT_TRUE(usage1 >= 0 && usage1 <= 100);
    CU_ASSERT_TRUE(usage2 >= 0 && usage2 <= 100);
    
    // 验证两次返回值的差异不应过大（假设差异不超过50%）
    int diff = abs(usage1 - usage2);
    CU_ASSERT_TRUE(diff <= 50);
}

/**
 * @brief 测试 cpu_scanDocker 函数在正常情况下的行为
 * 
 * 测试步骤：
 * 1. 确保 Docker 守护进程正在运行
 * 2. 启动一个测试容器
 * 3. 调用 cpu_scanDocker 函数
 * 4. 验证返回值和容器信息
 * 
 * 预期结果：
 * 1. 函数应该返回正确的容器数量
 * 2. dockerConfig 数组应该包含正确的容器信息
 */
void test_cpu_scanDocker_normal(void)
{
    // 分配内存给 dockerConfig
    dockerConfig = (dockerType *)malloc(sizeof(dockerType) * 10);
    CU_ASSERT_PTR_NOT_NULL(dockerConfig);

    // 启动测试容器
    system("docker run -d --name test_container busybox sleep 1000");
    
    // 调用被测试函数
    uint8_t container_count = cpu_scanDocker();
    
    // 验证至少检测到一个容器
    CU_ASSERT_TRUE(container_count > 0);
    
    // 验证容器信息是否被正确填充
    CU_ASSERT_TRUE(strlen(dockerConfig[0].name) > 0);
    CU_ASSERT_TRUE(strlen(dockerConfig[0].cpu_usage) > 0);
    CU_ASSERT_TRUE(strlen(dockerConfig[0].mem_usage) > 0);
    
    // 清理测试容器
    system("docker stop test_container && docker rm test_container");
    
    // 释放内存
    free(dockerConfig);
    dockerConfig = NULL;
}

/**
 * @brief 测试 cpu_scanDocker 函数在没有运行容器的情况
 * 
 * 测试步骤：
 * 1. 确保没有运行中的容器
 * 2. 调用 cpu_scanDocker 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 0
 * 2. dockerConfig 数组应该为空
 */
void test_cpu_scanDocker_no_containers(void)
{
    // 分配内存给 dockerConfig
    dockerConfig = (dockerType *)malloc(sizeof(dockerType) * 10);
    CU_ASSERT_PTR_NOT_NULL(dockerConfig);
    
    // 停止所有容器
    system("docker stop $(docker ps -aq) 2>/dev/null");
    system("docker rm $(docker ps -aq) 2>/dev/null");
    
    // 调用被测试函数
    uint8_t container_count = cpu_scanDocker();
    
    // 验证返回值为0
    CU_ASSERT_EQUAL(container_count, 0);
    
    // 释放内存
    free(dockerConfig);
    dockerConfig = NULL;
}

/**
 * @brief 测试 cpu_scanDocker 函数在 Docker 守护进程未运行的情况
 * 
 * 测试步骤：
 * 1. 模拟 Docker 守护进程未运行的情况
 * 2. 调用 cpu_scanDocker 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 0
 */
void test_cpu_scanDocker_daemon_not_running(void)
{
    // 分配内存给 dockerConfig
    dockerConfig = (dockerType *)malloc(sizeof(dockerType) * 10);
    CU_ASSERT_PTR_NOT_NULL(dockerConfig);
    
    // 停止 Docker 守护进程（需要 root 权限）
    system("sudo service docker stop");
    
    // 调用被测试函数
    uint8_t container_count = cpu_scanDocker();
    
    // 验证返回值为0
    CU_ASSERT_EQUAL(container_count, 0);
    
    // 重启 Docker 守护进程
    system("sudo service docker start");
    
    // 释放内存
    free(dockerConfig);
    dockerConfig = NULL;
}

/**
 * @brief 测试 cpu_scanDocker 函数在内存分配失败的情况
 * 
 * 测试步骤：
 * 1. 将 dockerConfig 设置为 NULL
 * 2. 调用 cpu_scanDocker 函数
 * 
 * 预期结果：
 * 1. 函数应该返回 0
 */
void test_cpu_scanDocker_memory_allocation_failure(void)
{
    // 设置 dockerConfig 为 NULL 模拟内存分配失败
    dockerConfig = NULL;
    
    // 调用被测试函数
    uint8_t container_count = cpu_scanDocker();
    
    // 验证返回值为0
    CU_ASSERT_EQUAL(container_count, 0);
}

/**
 * @brief 测试 get_flashUsage 函数在正常情况下的行为
 * 
 * 测试步骤：
 * 1. 创建一个字符数组用于存储结果
 * 2. 调用 get_flashUsage 函数获取闪存使用率
 * 3. 验证返回值和结果字符串的有效性
 * 
 * 预期结果：
 * 1. 函数返回值应该为0（成功）
 * 2. 结果字符串应该包含有效的百分比值（例如：75%）
 * 3. 百分比值应该在0-100之间
 */
void test_get_flashUsage_normal(void)
{
    char result[64] = {0};
    
    // 调用被测试函数
    uint8_t ret = get_flashUsage(result);
    
    // 验证返回值
    CU_ASSERT_EQUAL(ret, 0);
    
    // 验证结果字符串不为空
    CU_ASSERT_TRUE(strlen(result) > 0);
    
    // 验证结果格式（应该以%结尾）
    CU_ASSERT_TRUE(result[strlen(result)-1] == '%');
    
    // 验证使用率值在合理范围内
    int usage;
    sscanf(result, "%d%%", &usage);
    CU_ASSERT_TRUE(usage >= 0 && usage <= 100);
}

/**
 * @brief 测试 get_flashUsage 函数在命令执行失败的情况
 * 
 * 测试步骤：
 * 1. 通过修改PATH环境变量来模拟df命令不可用的情况
 * 2. 调用 get_flashUsage 函数
 * 3. 恢复PATH环境变量
 * 
 * 预期结果：
 * 1. 函数应该返回0（错误）
 * 2. 结果字符串应该为空
 */
void test_get_flashUsage_command_fail(void)
{
    char result[64] = {0};
    char old_path[1024];
    
    // 保存当前PATH
    strcpy(old_path, getenv("PATH"));
    // 设置错误的PATH
    setenv("PATH", "/invalid/path", 1);
    
    // 调用被测试函数
    uint8_t ret = get_flashUsage(result);
    
    // 恢复PATH
    setenv("PATH", old_path, 1);
    
    // 验证返回值
    CU_ASSERT_EQUAL(ret, 0);
    
    // 验证结果字符串为空
    CU_ASSERT_EQUAL(strlen(result), 0);
}

/**
 * @brief 测试 get_flashUsage 函数在结果参数为NULL的情况
 * 
 * 测试步骤：
 * 1. 使用NULL指针调用函数
 * 
 * 预期结果：
 * 1. 函数应该返回0（错误）
 * 2. 不应该发生段错误
 */
void test_get_flashUsage_null_parameter(void)
{
    // 调用被测试函数
    uint8_t ret = get_flashUsage(NULL);
    
    // 验证返回值
    CU_ASSERT_EQUAL(ret, 0);
}

/**
 * @brief 测试 get_flashUsage 函数在文件系统未挂载的情况
 * 
 * 测试步骤：
 * 1. 创建一个字符数组用于存储结果
 * 2. 调用 get_flashUsage 函数（当/userdata未挂载时）
 * 
 * 预期结果：
 * 1. 函数应该返回0（错误）
 * 2. 结果字符串应该为空
 */
void test_get_flashUsage_unmounted(void)
{
    char result[64] = {0};
    
    // 卸载/userdata分区（需要root权限）
    system("sudo umount /userdata 2>/dev/null");
    
    // 调用被测试函数
    uint8_t ret = get_flashUsage(result);
    
    // 重新挂载/userdata分区
    system("sudo mount /userdata 2>/dev/null");
    
    // 验证返回值
    CU_ASSERT_EQUAL(ret, 0);
    
    // 验证结果字符串为空
    CU_ASSERT_EQUAL(strlen(result), 0);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在时间差为负数的情况
 * 
 * 测试步骤：
 * 1. 创建两个 dev_cpu_info_t 结构体实例
 * 2. 设置第二个时间点的值小于第一个时间点
 * 3. 调用 cal_cpu_used_rate 函数计算使用率
 * 
 * 预期结果：
 * 1. 函数应该正确处理负数时间差的情况
 * 2. 返回值应该在0-100的合理范围内
 */
void test_cal_cpu_used_rate_negative_diff(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 设置第二个时间点小于第一个时间点
    first.user = 2000;
    first.nice = 400;
    first.system = 1000;
    first.idle = 16600;
    
    second.user = 1000;
    second.nice = 200;
    second.system = 500;
    second.idle = 8300;
    
    int usage = cal_cpu_used_rate(&first, &second);
    
    // 验证结果在合理范围内
    CU_ASSERT_TRUE(usage >= 0 && usage <= 100);
}

/**
 * @brief 测试 cpu_scanDocker 函数在Docker输出格式异常的情况
 * 
 * 测试步骤：
 * 1. 分配内存给 dockerConfig
 * 2. 创建模拟的异常输出脚本
 * 3. 修改环境变量使用模拟脚本
 * 4. 调用 cpu_scanDocker 函数
 * 
 * 预期结果：
 * 1. 函数应该能够优雅地处理异常格式
 * 2. 返回值应该为0表示错误
 * 3. 不应发生内存泄漏
 */
void test_cpu_scanDocker_invalid_format(void)
{
    // 分配内存给 dockerConfig
    dockerConfig = (dockerType *)malloc(sizeof(dockerType) * 10);
    CU_ASSERT_PTR_NOT_NULL(dockerConfig);
    
    // 创建一个模拟的异常输出脚本
    FILE *fp = fopen("mock_docker.sh", "w");
    fprintf(fp, "#!/bin/bash\n");
    fprintf(fp, "echo \"CONTAINER NAME CPU invalid format\"\n");
    fclose(fp);
    system("chmod +x mock_docker.sh");
    
    // 修改PATH以使用模拟脚本
    char old_path[1024];
    strcpy(old_path, getenv("PATH"));
    setenv("PATH", ".:$PATH", 1);
    
    // 调用被测试函数
    uint8_t container_count = cpu_scanDocker();
    
    // 恢复环境
    setenv("PATH", old_path, 1);
    system("rm mock_docker.sh");
    
    // 验证异常情况的处理
    CU_ASSERT_EQUAL(container_count, 0);
    
    // 释放内存
    free(dockerConfig);
    dockerConfig = NULL;
}

/**
 * @brief 测试 get_memUsage 函数在正常情况下的行为
 * 
 * 测试步骤：
 * 1. 调用 get_memUsage 函数获取内存使用率
 * 2. 验证返回值的合理性
 * 
 * 预期结果：
 * 1. 函数应该返回有效的内存使用率
 * 2. 返回值应该在0-100的合理范围内
 */
void test_get_memUsage_normal(void)
{
    uint8_t usage = get_memUsage();
    
    // 验证内存使用率在合理范围内
    CU_ASSERT_TRUE(usage >= 0 && usage <= 100);
}

/**
 * @brief 测试 get_memUsage 函数在文件不存在的情况
 * 
 * 测试步骤：
 * 1. 通过修改文件权限模拟文件不存在的情况
 * 2. 调用 get_memUsage 函数
 * 3. 恢复文件权限
 * 
 * 预期结果：
 * 1. 函数应该优雅地处理文件不存在的情况
 * 2. 返回值应该为0表示错误
 */
void test_get_memUsage_file_not_exist(void)
{
    // 通过修改文件权限来模拟文件不存在
    system("sudo chmod 000 /proc/meminfo");
    
    uint8_t usage = get_memUsage();
    
    // 恢复文件权限
    system("sudo chmod 444 /proc/meminfo");
    
    // 验证返回值为0
    CU_ASSERT_EQUAL(usage, 0);
}

/**
 * @brief 测试 get_memUsage 函数在文件格式错误的情况
 * 
 * 测试步骤：
 * 1. 创建格式错误的临时文件
 * 2. 替换原始文件
 * 3. 调用 get_memUsage 函数
 * 4. 恢复原始文件
 * 
 * 预期结果：
 * 1. 函数应该优雅地处理格式错误的情况
 * 2. 返回值应该为0表示错误
 */
void test_get_memUsage_invalid_format(void)
{
    // 创建一个格式错误的临时文件
    FILE *fp = fopen("test_meminfo", "w");
    fprintf(fp, "MemTotal: invalid\nMemFree: invalid\n");
    fclose(fp);
    
    // 备份并替换原始文件
    system("mv /proc/meminfo /proc/meminfo.bak");
    system("cp test_meminfo /proc/meminfo");
    
    uint8_t usage = get_memUsage();
    
    // 恢复原始文件
    system("mv /proc/meminfo.bak /proc/meminfo");
    system("rm test_meminfo");
    
    // 验证返回值为0
    CU_ASSERT_EQUAL(usage, 0);
}

/**
 * @brief 测试 get_memUsage 函数在内存值异常的情况
 * 
 * 测试步骤：
 * 1. 创建包含异常内存值的临时文件
 * 2. 替换原始文件
 * 3. 调用 get_memUsage 函数
 * 4. 恢复原始文件
 * 
 * 预期结果：
 * 1. 函数应该优雅地处理异常内存值
 * 2. 当总内存为0时返回值应该为0
 */
void test_get_memUsage_invalid_values(void)
{
    // 创建一个内存值异常的临时文件
    FILE *fp = fopen("test_meminfo", "w");
    fprintf(fp, "MemTotal: 0 kB\nMemFree: 1000 kB\n");
    fclose(fp);
    
    // 备份并替换原始文件
    system("mv /proc/meminfo /proc/meminfo.bak");
    system("cp test_meminfo /proc/meminfo");
    
    uint8_t usage = get_memUsage();
    
    // 恢复原始文件
    system("mv /proc/meminfo.bak /proc/meminfo");
    system("rm test_meminfo");
    
    // 验证返回值为0（因为MemTotal为0）
    CU_ASSERT_EQUAL(usage, 0);
}



/**
 * @brief 测试 get_memUsage 函数在内存压力测试情况下的行为
 * 
 * 测试目标：验证函数在内存压力大的情况下的准确性
 * 测试步骤：
 * 1. 获取初始内存使用率
 * 2. 创建内存压力
 * 3. 获取压力下的内存使用率
 * 
 * 预期结果：
 * 1. 函数应该能够准确反映内存使用率的变化
 * 2. 返回值应该在合理范围内
 */
void test_get_cpuUsage_high_load(void)
{
    // 创建高负载（使用yes命令输出到/dev/null）
    FILE *load = popen("yes > /dev/null", "r");
    
    // 等待负载生效
    usleep(100000);
    
    // 获取CPU使用率
    uint8_t usage = get_cpuUsage();
    
    // 停止负载
    pclose(load);
    
    // 验证CPU使用率是否反映高负载
    CU_ASSERT_TRUE(usage > 80);
}

void test_get_cpuUsage_low_load(void)
{
    // 等待系统空闲
    sleep(1);
    
    // 获取CPU使用率
    uint8_t usage = get_cpuUsage();
    
    // 验证CPU使用率是否反映低负载
    CU_ASSERT_TRUE(usage < 30);
}

void test_get_cpuUsage_freq_change(void)
{
    uint8_t usage1 = get_cpuUsage();
    
    // 执行密集计算
    for(int i = 0; i < 1000000; i++) {
        sqrt(i);
    }
    
    uint8_t usage2 = get_cpuUsage();
    
    // 验证CPU使用率变化
    CU_ASSERT_TRUE(usage2 > usage1);
}

void test_get_memUsage_allocation(void)
{
    uint8_t usage1 = get_memUsage();
    
    // 分配大量内存
    void *ptr = malloc(500 * 1024 * 1024);  // 500MB
    memset(ptr, 1, 500 * 1024 * 1024);
    
    uint8_t usage2 = get_memUsage();
    
    // 释放内存
    free(ptr);
    
    uint8_t usage3 = get_memUsage();
    
    // 验证内存使用率变化
    CU_ASSERT_TRUE(usage2 > usage1);
    CU_ASSERT_TRUE(usage2 > usage3);
}

void test_get_memUsage_pressure(void)
{
    uint8_t usage1 = get_memUsage();
    
    // 创建内存压力
    void *ptrs[10];
    for(int i = 0; i < 10; i++) {
        ptrs[i] = malloc(100 * 1024 * 1024);  // 每次100MB
        if(ptrs[i]) {
            memset(ptrs[i], 1, 100 * 1024 * 1024);
        }
    }
    
    uint8_t usage2 = get_memUsage();
    
    // 释放内存
    for(int i = 0; i < 10; i++) {
        if(ptrs[i]) {
            free(ptrs[i]);
        }
    }
    
    // 验证内存使用率
    CU_ASSERT_TRUE(usage2 > usage1);
}

void test_get_memUsage_after_cache_clear(void)
{
    uint8_t usage1 = get_memUsage();
    
    // 写入数据到文件以创建缓存
    FILE *fp = fopen("test_cache", "w");
    if(fp) {
        for(int i = 0; i < 1000000; i++) {
            fprintf(fp, "test data\n");
        }
        fclose(fp);
    }
    
    // 清理缓存
    system("echo 3 > /proc/sys/vm/drop_caches 2>/dev/null");
    
    uint8_t usage2 = get_memUsage();
    
    // 清理测试文件
    remove("test_cache");
    
    // 验证内存使用率变化
    CU_ASSERT_TRUE(usage2 <= usage1);
}

void test_get_flashUsage_large_file(void)
{
    char result1[64] = {0};
    char result2[64] = {0};
    
    // 获取初始使用率
    get_flashUsage(result1);
    
    // 创建大文件
    FILE *fp = fopen("large_test_file", "w");
    if(fp) {
        for(int i = 0; i < 1000000; i++) {
            fprintf(fp, "test data\n");
        }
        fclose(fp);
    }
    
    // 获取创建文件后的使用率
    get_flashUsage(result2);
    
    // 删除测试文件
    remove("large_test_file");
    
    // 解析使用率值
    int usage1, usage2;
    sscanf(result1, "%d%%", &usage1);
    sscanf(result2, "%d%%", &usage2);
    
    // 验证存储使用率变化
    CU_ASSERT_TRUE(usage2 >= usage1);
}

void test_get_flashUsage_frequent_io(void)
{
    char result[5][64];
    
    // 执行频繁IO操作并获取使用率
    for(int i = 0; i < 5; i++) {
        // 创建临时文件
        FILE *fp = fopen("test_file", "w");
        if(fp) {
            fprintf(fp, "test data\n");
            fclose(fp);
        }
        
        // 获取使用率
        get_flashUsage(result[i]);
        
        // 删除文件
        remove("test_file");
        
        // 短暂等待
        usleep(100000);
    }
    
    // 验证所有结果都是有效的
    for(int i = 0; i < 5; i++) {
        CU_ASSERT_TRUE(strlen(result[i]) > 0);
        CU_ASSERT_TRUE(result[i][strlen(result[i])-1] == '%');
    }
}

void test_get_cpu_info_multicore(void)
{
    dev_cpu_info_t cpu_info = {0};
    FILE *fp;
    char line[256];
    int core_count = 0;
    
    // 获取CPU核心数
    fp = fopen("/proc/cpuinfo", "r");
    if (fp) {
        while (fgets(line, sizeof(line), fp)) {
            if (strncmp(line, "processor", 9) == 0) {
                core_count++;
            }
        }
        fclose(fp);
    }
    
    // 确保至少检测到一个核心
    CU_ASSERT_TRUE(core_count > 0);
    
    // 对每个核心进行测试
    for (int i = 0; i < core_count; i++) {
        get_cpu_info(&cpu_info);
        
        // 验证每个核心的数据
        CU_ASSERT_TRUE(cpu_info.user > 0);
        CU_ASSERT_TRUE(cpu_info.system > 0);
        CU_ASSERT_TRUE(cpu_info.idle > 0);
    }
}

void test_get_cpu_info_state_change(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 创建CPU负载
    FILE *load = popen("yes > /dev/null", "r");
    usleep(100000);  // 等待负载生效
    
    // 获取负载下的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 停止负载
    pclose(load);
    
    // 验证CPU状态变化
    CU_ASSERT_TRUE(cpu_info2.user > cpu_info1.user);
    CU_ASSERT_TRUE(cpu_info2.system > cpu_info1.system);
}

void test_get_cpu_info_freq_spike(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 执行密集计算触发频率变化
    for(int i = 0; i < 1000000; i++) {
        sqrt(i);
    }
    
    // 获取变化后的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 验证CPU信息变化
    CU_ASSERT_TRUE(cpu_info2.user != cpu_info1.user);
}

void test_get_memUsage_fragmentation(void)
{
    uint8_t usage1, usage2;
    void *ptrs[100];
    
    // 获取初始内存使用率
    usage1 = get_memUsage();
    
    // 创建内存碎片
    for(int i = 0; i < 100; i++) {
        ptrs[i] = malloc(1024 * (i % 10 + 1));  // 不同大小的内存块
        if(ptrs[i]) {
            memset(ptrs[i], 1, 1024 * (i % 10 + 1));
        }
    }
    
    // 释放部分内存制造碎片
    for(int i = 0; i < 100; i += 2) {
        if(ptrs[i]) {
            free(ptrs[i]);
            ptrs[i] = NULL;
        }
    }
    
    // 获取碎片化后的内存使用率
    usage2 = get_memUsage();
    
    // 清理剩余内存
    for(int i = 1; i < 100; i += 2) {
        if(ptrs[i]) {
            free(ptrs[i]);
            ptrs[i] = NULL;
        }
    }
    
    // 验证内存使用率变化
    CU_ASSERT_TRUE(usage2 >= usage1);
}

void test_get_memUsage_swap_usage(void)
{
    uint8_t usage1, usage2;
    void *ptr;
    
    // 获取初始内存使用率
    usage1 = get_memUsage();
    
    // 分配大量内存可能触发swap
    ptr = malloc(1024 * 1024 * 1024);  // 1GB
    if(ptr) {
        memset(ptr, 1, 1024 * 1024 * 1024);
        
        // 获取可能使用swap后的内存使用率
        usage2 = get_memUsage();
        
        free(ptr);
        
        // 验证内存使用率变化
        CU_ASSERT_TRUE(usage2 > usage1);
    }
}

void test_get_memUsage_memory_leak(void)
{
    uint8_t usage1, usage2;
    
    // 获取初始内存使用率
    usage1 = get_memUsage();
    
    // 模拟内存泄漏（注意：这是测试代码，实际应该避免内存泄漏）
    for(int i = 0; i < 1000; i++) {
        malloc(1024);  // 故意不释放
    }
    
    // 获取泄漏后的内存使用率
    usage2 = get_memUsage();
    
    // 验证内存使用率增长
    CU_ASSERT_TRUE(usage2 > usage1);
}

void test_get_flashUsage_full_filesystem(void)
{
    char result1[64] = {0};
    char result2[64] = {0};
    FILE *fp;
    
    // 获取初始使用率
    get_flashUsage(result1);
    
    // 创建大文件
    fp = fopen("test_large_file", "w");
    if(fp) {
        for(int i = 0; i < 1000000; i++) {
            fprintf(fp, "test data block %d\n", i);
        }
        fclose(fp);
    }
    
    // 获取文件创建后的使用率
    get_flashUsage(result2);
    
    // 清理测试文件
    remove("test_large_file");
    
    // 解析使用率值
    int usage1, usage2;
    sscanf(result1, "%d%%", &usage1);
    sscanf(result2, "%d%%", &usage2);
    
    // 验证使用率增长
    CU_ASSERT_TRUE(usage2 > usage1);
}

void test_get_flashUsage_io_error(void)
{
    char result[64] = {0};
    
    // 创建只读目录模拟IO错误
    mkdir("test_readonly", 0444);
    
    // 尝试在只读目录中获取使用率
    uint8_t ret = get_flashUsage(result);
    
    // 清理测试目录
    rmdir("test_readonly");
    
    // 验证错误处理
    CU_ASSERT_EQUAL(ret, 0);
    CU_ASSERT_EQUAL(strlen(result), 0);
}

/**
 * @brief 测试 get_cpu_info 函数在CPU负载突然变化时的行为
 * 
 * 测试目标：验证函数在CPU负载突然变化时的准确性
 * 测试步骤：
 * 1. 获取初始CPU信息
 * 2. 创建突发负载
 * 3. 再次获取CPU信息
 * 
 * 预期结果：
 * 1. 函数应该能准确反映CPU负载的突变
 */
void test_get_cpu_info_load_change(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 创建CPU负载
    system("dd if=/dev/zero of=/dev/null bs=1M count=1000 2>/dev/null &");
    usleep(100000);  // 等待负载生效
    
    // 获取负载后的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 清理测试进程
    system("pkill dd 2>/dev/null");
    
    // 验证CPU使用时间的变化
    CU_ASSERT_TRUE(cpu_info2.user > cpu_info1.user);
    CU_ASSERT_TRUE(cpu_info2.system > cpu_info1.system);
}

/**
 * @brief 测试 get_cpu_info 函数在CPU中断频繁发生时的行为
 * 
 * 测试目标：验证函数在处理硬件中断时的准确性
 * 测试步骤：
 * 1. 获取初始CPU信息
 * 2. 触发大量网络中断
 * 3. 获取CPU信息
 * 
 * 预期结果：
 * 1. 函数应该能反映中断处理的CPU时间
 */
void test_get_cpu_info_interrupts(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 触发网络中断
    system("ping -f 127.0.0.1 -c 10000 2>/dev/null &");
    usleep(100000);
    
    // 获取中断处理后的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 停止ping
    system("pkill ping 2>/dev/null");
    
    // 验证系统时间的增加
    CU_ASSERT_TRUE(cpu_info2.system > cpu_info1.system);
}

/**
 * @brief 测试 get_cpu_info 函数在CPU软中断处理时的行为
 * 
 * 测试目标：验证函数在处理软中断时的准确性
 * 测试步骤：
 * 1. 获取初始CPU信息
 * 2. 触发软中断活动
 * 3. 获取CPU信息
 * 
 * 预期结果：
 * 1. 函数应该能反映软中断处理的CPU时间
 */
void test_get_cpu_info_softirq(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 触发软中断（通过网络活动）
    system("for i in {1..1000}; do curl -s http://localhost/ >/dev/null 2>&1; done &");
    usleep(100000);
    
    // 获取处理后的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 验证系统时间的变化
    CU_ASSERT_TRUE(cpu_info2.system > cpu_info1.system);
}

/**
 * @brief 测试 get_cpu_info 函数在CPU上下文切换频繁时的行为
 * 
 * 测试目标：验证函数在频繁上下文切换时的准确性
 * 测试步骤：
 * 1. 获取初始CPU信息
 * 2. 创建多线程负载
 * 3. 获取CPU信息
 * 
 * 预期结果：
 * 1. 函数应该能反映上下文切换的开销
 */
void test_get_cpu_info_context_switch(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 创建多线程负载
    system("for i in {1..10}; do yes >/dev/null & done");
    usleep(100000);
    
    // 获取负载后的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 清理测试进程
    system("pkill yes 2>/dev/null");
    
    // 验证系统时间的增加
    CU_ASSERT_TRUE(cpu_info2.system > cpu_info1.system);
}

/**
 * @brief 测试 get_memUsage 函数在大页内存使用时的行为
 * 
 * 测试目标：验证函数在使用大页内存时的准确性
 * 测试步骤：
 * 1. 配置并分配大页内存
 * 2. 获取内存使用率
 * 
 * 预期结果：
 * 1. 函数应该能正确计算包含大页的内存使用率
 */
void test_get_memUsage_huge_pages(void)
{
    uint8_t usage1, usage2;
    
    // 获取初始内存使用率
    usage1 = get_memUsage();
    
    // 配置大页
    system("echo 20 > /proc/sys/vm/nr_hugepages 2>/dev/null");
    usleep(100000);
    
    // 获取配置后的内存使用率
    usage2 = get_memUsage();
    
    // 清理大页配置
    system("echo 0 > /proc/sys/vm/nr_hugepages 2>/dev/null");
    
    // 验证内存使用率的变化
    CU_ASSERT_TRUE(usage2 >= usage1);
}

/**
 * @brief 测试 get_memUsage 函数在NUMA节点间内存迁移时的行为
 * 
 * 测试目标：验证函数在NUMA内存迁移时的准确性
 * 测试步骤：
 * 1. 获取初始内存使用率
 * 2. 触发NUMA内存迁移
 * 3. 获取内存使用率
 * 
 * 预期结果：
 * 1. 函数应该能正确反映内存使用状态
 */
void test_get_memUsage_numa_migration(void)
{
    uint8_t usage1, usage2;
    
    // 获取初始内存使用率
    usage1 = get_memUsage();
    
    // 分配内存并触发NUMA迁移
    system("numactl --preferred=1 stress --vm 1 --vm-bytes 128M --timeout 1s 2>/dev/null");
    
    // 获取迁移后的内存使用率
    usage2 = get_memUsage();
    
    // 验证内存使用率变化在合理范围内
    CU_ASSERT_TRUE(abs(usage2 - usage1) <= 10);
}

/**
 * @brief 测试 get_flashUsage 函数在文件系统碎片化时的行为
 * 
 * 测试目标：验证函数在文件系统碎片化时的准确性
 * 测试步骤：
 * 1. 创建碎片化的文件系统状态
 * 2. 获取存储使用率
 * 
 * 预期结果：
 * 1. 函数应该能正确报告存储使用情况
 */
void test_get_flashUsage_fragmentation(void)
{
    char result1[64] = {0};
    char result2[64] = {0};
    
    // 获取初始存储使用率
    get_flashUsage(result1);
    
    // 创建碎片化状态
    system("dd if=/dev/zero of=test_file1 bs=4K count=1000 2>/dev/null");
    system("dd if=/dev/zero of=test_file2 bs=4K count=1000 2>/dev/null");
    system("rm test_file1");
    system("dd if=/dev/zero of=test_file3 bs=4K count=500 2>/dev/null");
    
    // 获取碎片化后的存储使用率
    get_flashUsage(result2);
    
    // 清理测试文件
    system("rm test_file2 test_file3");
    
    // 验证使用率变化
    int usage1, usage2;
    sscanf(result1, "%d%%", &usage1);
    sscanf(result2, "%d%%", &usage2);
    CU_ASSERT_TRUE(usage2 > usage1);
}

/**
 * @brief 测试 get_flashUsage 函数在inode耗尽时的行为
 * 
 * 测试目标：验证函数在inode接近耗尽时的准确性
 * 测试步骤：
 * 1. 创建大量小文件消耗inode
 * 2. 获取存储使用率
 * 
 * 预期结果：
 * 1. 函数应该能正确处理inode耗尽的情况
 */
void test_get_flashUsage_inode_exhaustion(void)
{
    char result1[64] = {0};
    char result2[64] = {0};
    
    // 获取初始存储使用率
    get_flashUsage(result1);
    
    // 创建大量小文件
    system("mkdir test_files");
    system("for i in {1..1000}; do touch test_files/file$i; done");
    
    // 获取创建文件后的存储使用率
    get_flashUsage(result2);
    
    // 清理测试文件
    system("rm -rf test_files");
    
    // 验证使用率
    int usage1, usage2;
    sscanf(result1, "%d%%", &usage1);
    sscanf(result2, "%d%%", &usage2);
    CU_ASSERT_TRUE(usage2 >= usage1);
}

/**
 * @brief 测试 get_cpu_info 函数在CPU热插拔情况下的行为
 * 
 * 测试目标：验证函数在CPU核心数量动态变化时的行为
 * 测试步骤：
 * 1. 模拟CPU核心离线
 * 2. 获取CPU信息
 * 3. 模拟CPU核心上线
 * 4. 再次获取CPU信息
 * 
 * 预期结果：
 * 1. 函数应该正确处理CPU核心数量的变化
 * 2. 返回的数据应该反映实际的CPU状态
 */
void test_get_cpu_info_hotplug(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 模拟CPU核心离线（通过修改/sys/devices/system/cpu/cpu1/online）
    system("echo 0 > /sys/devices/system/cpu/cpu1/online 2>/dev/null");
    
    // 获取CPU离线后的信息
    get_cpu_info(&cpu_info2);
    
    // 恢复CPU核心
    system("echo 1 > /sys/devices/system/cpu/cpu1/online 2>/dev/null");
    
    // 验证函数在CPU配置变化时的行为
    CU_ASSERT_TRUE(cpu_info1.user != 0);
    CU_ASSERT_TRUE(cpu_info2.user != 0);
}

/**
 * @brief 测试 get_cpu_info 函数在CPU频率动态调整时的行为
 * 
 * 测试目标：验证函数在CPU频率变化时的数据准确性
 * 测试步骤：
 * 1. 获取初始CPU信息
 * 2. 执行密集计算任务
 * 3. 再次获取CPU信息
 * 
 * 预期结果：
 * 1. 函数应该反映CPU使用状态的变化
 * 2. 数据应该显示增加的系统负载
 */
void test_get_cpu_info_freq_scaling(void)
{
    dev_cpu_info_t cpu_info1 = {0};
    dev_cpu_info_t cpu_info2 = {0};
    
    // 获取初始CPU信息
    get_cpu_info(&cpu_info1);
    
    // 执行密集计算任务
    for(int i = 0; i < 1000000; i++) {
        sqrt(i);
    }
    
    // 获取执行任务后的CPU信息
    get_cpu_info(&cpu_info2);
    
    // 验证CPU使用率变化
    CU_ASSERT_TRUE(cpu_info2.user > cpu_info1.user);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在极端CPU使用率情况下的行为
 * 
 * 测试目标：验证函数在CPU使用率接近0%和100%时的计算准确性
 * 测试步骤：
 * 1. 测试接近0%的使用率
 * 2. 测试接近100%的使用率
 * 
 * 预期结果：
 * 1. 极低使用率应该正确计算为接近0
 * 2. 极高使用率应该正确计算为接近100
 */
void test_cal_cpu_used_rate_extreme_usage(void)
{
    dev_cpu_info_t first = {0};
    dev_cpu_info_t second = {0};
    
    // 测试接近0%的使用率
    first.user = 1000;
    first.system = 1000;
    first.idle = 98000;
    
    second.user = 1001;
    second.system = 1001;
    second.idle = 197998;
    
    int low_usage = cal_cpu_used_rate(&first, &second);
    CU_ASSERT_TRUE(low_usage <= 2);
    
    // 测试接近100%的使用率
    first.user = 98000;
    first.system = 1000;
    first.idle = 1000;
    
    second.user = 197000;
    second.system = 2000;
    second.idle = 1000;
    
    int high_usage = cal_cpu_used_rate(&first, &second);
    CU_ASSERT_TRUE(high_usage >= 98);
}

/**
 * @brief 测试 cal_cpu_used_rate 函数在CPU状态快速变化时的行为
 * 
 * 测试目标：验证函数在CPU负载快速变化时的计算准确性
 * 测试步骤：
 * 1. 模拟CPU状态的快速变化
 * 2. 多次计算CPU使用率
 * 
 * 预期结果：
 * 1. 函数应该能够准确反映CPU使用率的变化
 * 2. 计算结果应该在合理范围内
 */
void test_cal_cpu_used_rate_rapid_changes(void)
{
    dev_cpu_info_t samples[5] = {0};
    int usages[4] = {0};
    
    // 模拟CPU状态快速变化
    for(int i = 0; i < 5; i++) {
        samples[i].user = 1000 * (i + 1);
        samples[i].system = 500 * (i + 1);
        samples[i].idle = 8500 - (1000 * i);
    }
    
    // 计算连续的CPU使用率
    for(int i = 0; i < 4; i++) {
        usages[i] = cal_cpu_used_rate(&samples[i], &samples[i+1]);
        CU_ASSERT_TRUE(usages[i] >= 0 && usages[i] <= 100);
    }
    
    // 验证使用率变化的连续性
    for(int i = 1; i < 4; i++) {
        int diff = abs(usages[i] - usages[i-1]);
        CU_ASSERT_TRUE(diff <= 50);  // 相邻采样点的差异不应过大
    }
}

/**
 * @brief 测试 get_cpuUsage 函数在系统负载突变的情况
 * 
 * 测试目标：验证函数在系统负载突然变化时的响应
 * 测试步骤：
 * 1. 获取初始CPU使用率
 * 2. 创建突发负载
 * 3. 再次获取CPU使用率
 * 
 * 预期结果：
 * 1. 函数应该能够检测到负载的突变
 * 2. 返回值应该反映实际的系统状态
 */
void test_get_cpuUsage_load_spike(void)
{
    uint8_t usage1, usage2;
    
    // 获取初始CPU使用率
    usage1 = get_cpuUsage();
    
    // 创建突发负载
    system("dd if=/dev/zero of=/dev/null bs=1M count=1000 2>/dev/null &");
    usleep(100000);  // 等待负载生效
    
    // 获取负载后的CPU使用率
    usage2 = get_cpuUsage();
    
    // 清理测试进程
    system("pkill dd 2>/dev/null");
    
    // 验证CPU使用率的变化
    CU_ASSERT_TRUE(usage2 >= usage1);
}

/**
 * @brief 测试 cpu_scanDocker 函数在容器状态频繁变化的情况
 * 
 * 测试目标：验证函数在容器状态快速变化时的稳定性
 * 测试步骤：
 * 1. 启动多个测试容器
 * 2. 在容器状态变化时多次调用函数
 * 3. 验证返回结果的一致性
 * 
 * 预期结果：
 * 1. 函数应该能够正确追踪容器状态的变化
 * 2. 返回的数据应该保持一致性
 */
void test_cpu_scanDocker_state_changes(void)
{
    dockerConfig = (dockerType *)malloc(sizeof(dockerType) * 10);
    CU_ASSERT_PTR_NOT_NULL(dockerConfig);
    
    // 启动测试容器
    system("docker run -d --name test_container1 busybox sleep 30");
    system("docker run -d --name test_container2 busybox sleep 30");
    
    uint8_t count1 = cpu_scanDocker();
    
    // 停止一个容器
    system("docker stop test_container1");
    
    uint8_t count2 = cpu_scanDocker();
    
    // 启动新容器
    system("docker run -d --name test_container3 busybox sleep 30");
    
    uint8_t count3 = cpu_scanDocker();
    
    // 清理测试容器
    system("docker stop test_container2 test_container3");
    system("docker rm test_container1 test_container2 test_container3");
    
    // 验证容器计数的变化
    CU_ASSERT_TRUE(count1 == 2);
    CU_ASSERT_TRUE(count2 == 1);
    CU_ASSERT_TRUE(count3 == 2);
    
    free(dockerConfig);
    dockerConfig = NULL;
}




